package 泛型;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

//泛型类可以充当超类或者作为子类。在泛型层次结构中，需要任何类型参数由泛型超类必须由所有子类向上传递到层次结构。
//例1:使用泛型超类

/*class MyClass2<T> {
	T ob;

	MyClass2(T o) {
		ob = o;
	}

	T getob() {
		return ob;
	}
}

class MySubclass<T, V> extends MyClass2<T> {
	V ob2;

	MySubclass(T o, V o2) {
		super(o);
		ob2 = o2;
	}

	V getob2() {
		return ob2;
	}
}

public class 泛型类继承 {
	public static void main(String args[]) {
		MySubclass<String, Integer> x = new MySubclass<String, Integer>("Value is: ", 99);
		System.out.print(x.getob());
		System.out.println(x.getob2());
        //Value is: 99

    }
}*/


//例2 非类属类(基本类型)是类属子类的超类是完全可以接受的。

/*class MyClass2 {
	int num;

	MyClass2(int i) {
		num = i;
	}

	int getnum() {
		return num;
	}
}

class MySubclass<T> extends MyClass2 {
	T ob;

	MySubclass(T o, int i) {
		super(i);
		ob = o;
	}

	T getob() {
		return ob;
	}
}

public class 泛型类继承 {
	public static void main(String args[]) {
		MySubclass<String> w = new MySubclass<String>("Hello", 4);
		System.out.println(w.getClass());//class 泛型.MySubclass
		System.out.print(w.getob() + " ");
		System.out.println(w.getnum());
		//Hello 4
	}
}*/

//例3 instanceof运算符可以应用于泛型类的对象。

class Gen<T> {
	T ob;

	Gen(T o) {
		ob = o;
	}

	T getob() {
		return ob;
	}
}

class Gen2<T> extends Gen<T> {
	Gen2(T o) {
		super(o);
	}
}

public class 泛型类继承 {
  public static void main(String args[]) {
    Gen<Integer> iOb = new Gen<Integer>(88);
    Gen2<Integer> iOb2 = new Gen2<Integer>(99);
    Gen2<String> strOb2 = new Gen2<String>("Generics Test");
    System.out.println("iOb2 is instance of Gen2 "+(iOb2 instanceof Gen2<?>));
    System.out.println("iOb2 is instance of Gen "+(iOb2 instanceof Gen<?>));
    System.out.println("strOb2 is instance of Gen2 "+(strOb2 instanceof Gen2<?>));
    System.out.println("strOb2 is instance of Gen "+(strOb2 instanceof Gen<?>));
    System.out.println("iOb is instance of Gen2 "+(iOb instanceof Gen2<?>));
    System.out.println("iOb is instance of Gen "+(iOb instanceof Gen<?>));
  }
}

//例4 泛型类中的方法可以像任何其他方法一样重写。
//
//class Gen<T> {
//	T obj;
//
//	Gen(T o) {
//		obj = o;
//	}
//
//	T getob() {
//    System.out.print("Gen"s getob(): ");
//    return obj;
//  }
//}
//
//class Gen2<T> extends Gen<T> {
//	Gen2(T o) {
//		super(o);
//	}
//
//	T getob() {
//    System.out.print("Gen2"s getob(): ");
//    return obj;
//  }
//}
//
//public class Main {
//	public static void main(String args[]) {
//		Gen<Integer> iOb = new Gen<Integer>(88);
//		Gen2<String> strOb2 = new Gen2<String>("Generics Test");
//		System.out.println(iOb.getob());
//		System.out.println(strOb2.getob());
//	}
//}上面的代码生成以下结果。
//
//Java泛型类型转换 你可以将一个泛型类的一个实例转换成另一个只有两个是兼容的，它们的类型参数是相同的。
//
//例如，假设以下程序，此强制转换是合法的:
//
//class Gen<T> {
//	T ob;
//
//	Gen(T o) {
//		ob = o;
//	}
//
//	T getob() {
//		return ob;
//	}
//}
//
//class Gen2<T> extends Gen<T> {
//	Gen2(T o) {
//		super(o);
//	}
//}
//
//public class Main {
//	public static void main(String args[]) {
//		Gen<Integer> iOb = new Gen<Integer>(88);
//		Gen2<Integer> iOb2 = new Gen2<Integer>(99);
//		Gen2<String> strOb2 = new Gen2<String>("Generics Test");
//		iOb = (Gen<Integer>) iOb2;
//	}}
//
//因为iOb2是Gen< Integer>的实例。但是，这个演员:
//
//	class Gen<T> {
//		T ob;
//
//		Gen(T o) {
//			ob = o;
//		}
//
//		T getob() {
//			return ob;
//		}
//	}
//
//	class Gen2<T> extends Gen<T> {
//		Gen2(T o) {
//			super(o);
//		}
//	}
//
//	public class Main {
//		public static void main(String args[]) {
//			Gen<Integer> iOb = new Gen<Integer>(88);
//			Gen2<Integer> iOb2 = new Gen2<Integer>(99);
//			Gen2<String> strOb2 = new Gen2<String>("Generics Test");
//			// iOb = (Gen<Long>) iOb2;//wrong
//		}
//}是不合法的，因为iOb2不是Gen<Long>的实例

